package com.gzh.core.util;

import lombok.extern.slf4j.Slf4j;

import java.math.BigDecimal;

/**
 * @Author ailike
 * @Date 2021/11/15
 * @Description
 */
@Slf4j
public class NumericHelper {

    /**
     * 如果num数字为null则返回默认值0，否则返回num
     * @param num
     * @return
     */
    public static Integer zeroNull(Integer num){
        return num!=null ?  num : 0;
    }

    /**
     * 如果num数字为null则返回默认值defaultNum（如果defaultNum为null则返回0），否则返回num
     * @param num
     * @param defaultNum
     * @return
     */
    public static Integer zeroNull(Integer num, Integer defaultNum){
        return num!=null ?  num : zeroNull(defaultNum);
    }

    /**
     * 如果num数字为null则返回默认值0L，否则返回num
     * @param num
     * @return
     */
    public static Long zeroNull(Long num){
        return num!=null ?  num : 0;
    }

    /**
     * 如果num数字为null则返回默认值defaultNum（如果defaultNum为null则返回0L），否则返回num
     * @param num
     * @param defaultNum
     * @return
     */
    public static Long zeroNull(Long num, Long defaultNum){
        return num!=null ?  num : zeroNull(defaultNum);
    }

    /**
     * 如果num数字为null则返回默认值0D，否则返回num
     * @param num
     * @return
     */
    public static Double zeroNull(Double num){
        return num!=null ?  num : 0;
    }

    /**
     * 如果num数字为null则返回默认值defaultNum（如果defaultNum为null则返回0D），否则返回num
     * @param num
     * @param defaultNum
     * @return
     */
    public static Double zeroNull(Double num, Double defaultNum){
        return num!=null ?  num : zeroNull(defaultNum);
    }

    /**
     * 如果num数字为null则返回默认值0，否则返回num
     * @param num
     * @return
     */
    public static BigDecimal zeroNull(BigDecimal num){
        return num!=null ?  num : BigDecimal.ZERO;
    }

    /**
     * 判断是否是数字
     * @param str
     * @return
     */
    public static boolean isNumeric(String str){
        if(StringUtils.isEmpty(str)){
            return false;
        }
        for (int i = 0; i < str.length(); i++){
            if (!Character.isDigit(str.charAt(i))){
                return false;
            }
        }
        return true;
    }

    /**
     * 将string类型数字转换为Long类型数字
     * @param strValue
     * @return
     */
    public static Long toLong(String strValue) {
        Long longValue = null;
        if (StringUtils.isNotEmpty(strValue)) {
            try {
                longValue = Long.parseLong(strValue);
            } catch (NumberFormatException var4) {
                log.warn("toLong类型转换出错了："+strValue);
            }
        }
        return longValue;
    }

    /**
     * 将string类型数字转换为Long类型数字
     * @param strValue
     * @return
     */
    public static Long toLongZeroNull(String strValue) {
        Long longValue = 0L;
        if (StringUtils.isNotEmpty(strValue)) {
            try {
                longValue = Long.parseLong(strValue);
            } catch (NumberFormatException var4) {
                log.warn("toLongZeroNull类型转换出错了："+strValue);
            }
        }
        return longValue;
    }

    /**
     * 将string类型数字转换为Integer类型数字
     * @param strValue
     * @return
     */
    public static Integer toInteger(String strValue) {
        Integer integerValue = null;
        if (StringUtils.isNotEmpty(strValue)) {
            try {
                integerValue = Integer.parseInt(strValue);
            } catch (NumberFormatException var4) {
                log.warn("toInteger类型转换出错了："+strValue);
            }
        }
        return integerValue;
    }

    /**
     * 将string类型数字转换为Integer类型数字
     * @param strValue
     * @return
     */
    public static Integer toIntegerZeroNull(String strValue) {
        Integer integerValue = 0;
        if (StringUtils.isNotEmpty(strValue)) {
            try {
                integerValue = Integer.parseInt(strValue);
            } catch (NumberFormatException var4) {
                log.warn("toIntegerZeroNull类型转换出错了："+strValue);
            }
        }
        return integerValue;
    }

    /**
     * Long类型数据转Integer类型数据
     * @param longValue
     * @return
     */
    public static Integer toInteger(Long longValue) {
        String strValue = StringUtils.toString(longValue);
        return toInteger(strValue);
    }

    /**
     * 将string类型数字转换为Double类型数字
     * @param strValue
     * @return
     */
    public static Double toDouble(String strValue) {
        Double doubleValue = null;
        if (StringUtils.isNotEmpty(strValue)) {
            try {
                doubleValue = Double.parseDouble(strValue);
            } catch (NumberFormatException var4) {
                log.warn("toDouble类型转换出错了："+strValue);
            }
        }
        return doubleValue;
    }

    /**
     * 将string类型数字转换为Double类型数字
     * @param strValue
     * @return
     */
    public static Double toDoubleZeroNull(String strValue) {
        Double doubleValue = 0D;
        if (StringUtils.isNotEmpty(strValue)) {
            try {
                doubleValue = Double.parseDouble(strValue);
            } catch (NumberFormatException var4) {
                log.warn("toDoubleZeroNull类型转换出错了："+strValue);
            }
        }
        return doubleValue;
    }

    /**
     * 将string类型数字转换为Double类型数字
     * @param bdValue
     * @return
     */
    public static Double toDouble(BigDecimal bdValue) {
        Double doubleValue = null;
        if (bdValue!=null) {
            try {
                doubleValue = bdValue.doubleValue();
            } catch (NumberFormatException var4) {
                log.warn("toDouble类型转换出错了："+bdValue);
            }
        }
        return doubleValue;
    }
    /**
     * 将string类型数字转换为Double类型数字
     * @param bdValue
     * @return
     */
    public static Double toDouble(BigDecimal bdValue,Double defaultValue) {
        Double doubleValue = defaultValue;
        if (bdValue!=null) {
            try {
                doubleValue = bdValue.doubleValue();
            } catch (NumberFormatException var4) {
                log.warn("toDouble类型转换出错了："+bdValue);
            }
        }
        return doubleValue;
    }

    /**
     * 将Double类型数字转换为BigDecimal类型数字
     * @param doubleValue
     * @return
     */
    public static BigDecimal toBigDecimal(Double doubleValue) {
        BigDecimal bd = null;
        if (doubleValue != null) {
            try {
                // 因为double转BigDecimal时可能会出现精度问题，而用double转string后再转BigDecimal不会有精度问题
                bd = new BigDecimal(doubleValue.toString());
            } catch (NumberFormatException var4) {
                log.warn("toBigDecimal类型转换出错了："+doubleValue);
            }
        }
        return bd;
    }

    /**
     * 将Double类型数字转换为BigDecimal类型数字
     * @param doubleValue
     * @return
     */
    public static BigDecimal toBigDecimal(Double doubleValue, BigDecimal defaultValue) {
        BigDecimal bd = defaultValue;
        if (doubleValue != null) {
            try {
                // 因为double转BigDecimal时可能会出现精度问题，而用double转string后再转BigDecimal不会有精度问题
                bd = new BigDecimal(doubleValue.toString());
            } catch (NumberFormatException var4) {
                log.warn("toBigDecimal类型转换出错了："+doubleValue);
            }
        }
        return bd;
    }

    /**
     * 把Integer类型数字转换为BigDecimal类型数字
     * @param value
     * @return
     */
    public static BigDecimal toBigDecimal(Integer value) {
        BigDecimal bd = null;
        if (value != null) {
            try {
                bd = new BigDecimal(value);
            } catch (NumberFormatException var4) {
                log.warn("toBigDecimal类型转换出错了："+value);
            }
        }
        return bd;
    }

    /**
     * 把String类型数据转换为BigDecimal类型数据
     * @param value
     * @return
     */
    public static BigDecimal toBigDecimal(String value) {
        BigDecimal bd = null;
        if (value != null) {
            try {
                bd = new BigDecimal(value);
            } catch (NumberFormatException var4) {
                log.warn("toBigDecimal类型转换出错了："+value);
            }
        }
        return bd;
    }

    /**
     * 将Double类型数字转换为BigDecimal类型数字
     * @param doubleValue
     * @return
     */
    public static BigDecimal toBigDecimalZeroNull(Double doubleValue) {
        BigDecimal bd = BigDecimal.ZERO;
        if (doubleValue != null) {
            try {
                // 因为double转BigDecimal时可能会出现精度问题，而用double转string后再转BigDecimal不会有精度问题
                bd = new BigDecimal(doubleValue.toString());
            } catch (NumberFormatException var4) {
                log.warn("toBigDecimalZeroNull类型转换出错了："+doubleValue);
            }
        }
        return bd;
    }

    /**
     * 把String类型数据转换为BigDecimal类型数据
     * @param value
     * @return
     */
    public static BigDecimal toBigDecimalZeroNull(String value) {
        BigDecimal bd = BigDecimal.ZERO;
        if (value != null) {
            try {
                bd = new BigDecimal(value);
            } catch (NumberFormatException var4) {
                log.warn("toBigDecimal类型转换出错了："+value);
            }
        }
        return bd;
    }
}
